/**
 * ParaContour
 *
 */

if(typeof (module) !="undefined"){
    module.exports = ParaContour;

    var PointPath = require('./PointPath');
    var CompoundPath = require('./CompoundPath');
    var OnePara = require('./OnePara');
    var FMatrix = require('./FMatrix');
    var define = require('../../define').getDefine();

}


function ParaContour()
{
    // 包含多个单行段落
    this.paras = new Array();
    this.w = 0;
    this.h = 0;

    this.m=null; // 变换矩阵（相对于原始轮廓（从服务器返回的轮廓）的绝对缩放矩阵）
}
// 转成json字符串
// 参数： frame为true，表示转成frame（所谓frame指的是文字的每个字的x、y、w、h，但不包括文字的每个点）
ParaContour.prototype.toJson = function(frame ){
    frame = (typeof frame ==undefined || typeof frame ==undefined)? false:frame;

    var ret = '{';
    ret +='"paras":[';
    for(var i=0;i<this.paras.length;i++){
        if(i>0){
            ret +=',';
        }
        ret += this.paras[i].toJson(frame );
    }
    ret +=']';
    ret +=',';
    ret +=('"w":'+this.w);
    ret +=',';
    ret +=('"h":'+this.h);
    // matrix
    if(this.m){
        ret +=',';
        ret +=('"m":'+this.m.toJson());
    }
    ret +='}';
    return ret;
}
// 从json对象中解析
// 参数： frame为true，表示从frame中解析（所谓frame指的是文字的每个字的x、y、w、h，但不包括文字的每个点）
ParaContour.prototype.fromJson = function(jsonObj, versionId, frame){
    frame = (typeof frame ==undefined || typeof frame ==undefined)? false:frame;

    this.paras.splice(0,this.paras.length);
    if(jsonObj && jsonObj.hasOwnProperty('paras')){
        for(var i=0;i<jsonObj.paras.length;i++){
            var para= new OnePara();
            para.fromJson(jsonObj.paras[i],versionId,frame);
            this.paras.push(para);
        }
    }
    this.w = jsonObj.w*1;
    this.h = jsonObj.h*1;

    // matrix
    if(jsonObj.hasOwnProperty('m')){
        this.m = new FMatrix();
        this.m.fromJson(jsonObj.m);
    }
}
/**
 * 利用ParaControu的矩阵和CompoundPath的矩阵更新轮廓点
 */
ParaContour.prototype.multiplyMatrix= function(){
    // 变换矢量
    for(var k = 0; k < this.paras.length; k++) {
        var para = this.paras[k];
        para.multiplyMatrix(this.m);
    }
}
/**
 * 转换成SVG格式的字符串数组：
 *  [[
 *      'M 0,20 L 100,160 Q 130,200 150,120 C 190,-40 200,200 300,150 L 400,90 z
 *       M 0,20 L 100,160 Q 130,200 150,120 C 190,-40 200,200 300,150 L 400,90 z'
 *  ]]
 */
ParaContour.prototype.toSvgPath= function(){
    var ret = new Array();
    for(var i=0;i<this.paras.length;i++){
        ret.push(this.paras[i].toSvgPath());
    }
    return ret;
}
// 调整多行段落，平移或者缩放
// 参数
//		charContour:复合路径
//		vW:水平方向的平移值或者缩放值
//		vH:垂直方向的平移值或者缩放值
// 		type:类型，1 平移  2 缩放
ParaContour.prototype.adjustPosition = function(vW, vH, type){
    if(2==type){
        this.w *= vW;
        this.h *= vH;
    }
    
    for(var i = 0; i < this.paras.length; i++){
        var onePara = this.paras[i];
        onePara.adjustPosition( vW, vH, 2);
    }
}

// 用途：自身是frame数据，charPts是字的点数据，根据charPts设置自身的点
// 参数：
//		charPts：字的点数据
//		keepFrame：true  表示保持fText的frame，只根据服务器返回的数据更新字的点；
//				false 表示不保留fText的frame，根据服务器返回的数据更新其frame和字的点
ParaContour.prototype.adjustByCharPts = function (charPts, keepFrame){
    if(!keepFrame)
        this.fromJson(charPts, define.VERSION_CURRENT,false);
    else{

        // 检测是否有效数据
        if(this.paras.length != charPts.paras.length)	return ;
        for(var i = 0; i < this.paras.length; i++){
            if(this.paras[i].chars.length != charPts.paras[i].chars.length)	return;
        }
        // 按轮廓调整文字
        for(var i = 0; i < this.paras.length; i++){
            var onePara = this.paras[i] ;
            for(var j=0; j<onePara.chars.length; j++){
                var frame = onePara.chars[j];
                var frameW = frame.w;
                var frameH = frame.h;
                var frameX = frame.x;
                var frameY = frame.y;
                // 先将点轮廓拷贝过来
                frame.fromJson(charPts.paras[i].chars[j],define.VERSION_CURRENT, false);
                // 再按frame调整点
                frame.adjustPosition(frameW/frame.w, frameH/frame.h, 2);
                frame.x = frameX; frame.y = frameY;

            }
        }


    }
}

// 用途：自身是frame数据，charPts是字的点数据，根据charPts设置自身的点
// 参数：
//		charPts：字的点数据(ParaContour对应的Object类型)
ParaContour.prototype.updateCharPtsFromSrv = function(charPts){
    // 删除多余的段落和字
    for(var i = this.paras.length-1; i>=0 ; i--){
        if(i >= charPts.paras.length){// 删除多余段
            this.paras.splice(i, 1);
            continue;
        }
    
        var oneParaLoc = this.paras[i] ;
        var oneParaSrv = charPts.paras[i] ;
        for(var j=oneParaLoc.chars.length-1; j>=0; j--){// 删除多余字
            if(j >= oneParaSrv.chars.length){
                oneParaLoc.chars.splice(j, 1);
                continue;
            }
        }
    }
    
    // 按轮廓调整文字
    for(var i = 0; i < charPts.paras.length; i++){
        var onePara = charPts.paras[i] ;
        for(var j=0; j<onePara.chars.length; j++){
            var charSrv = onePara.chars[j];
            // 服务器返回字数在本地字数范围内
            var charLoc = null;
            var lastCharLoc =null;
            if( i<this.paras.length && j< this.paras[i].chars.length){
                // 根据服务器返回的字轮廓创建本地文字的轮廓
                charLoc = 	this.paras[i].chars[j];
                charLoc.paths.splice(0,charLoc.paths.length);// 清除旧路径
                lastCharLoc = charLoc;
            }else if(i>=this.paras.length){
                // 服务器返回字数超出本地字数范围，则用最后一个本地字的matrix创建新文字
                var lastPara= this.paras[this.paras.length-1];
                lastCharLoc = lastPara.chars[lastPara.chars.length-1];
                // 创建新段
                var newPara = new OnePara();
                this.paras.push(newPara);
                // 创建新字
                charLoc = 	new CompoundPath();
                newPara.chars.push(charLoc);
            }else{
                // 服务器返回字数超出本地字数范围，则用最后一个本地字的matrix创建新文字
                var lastPara= this.paras[i];
                lastCharLoc = lastPara.chars[lastPara.chars.length-1];
                // 创建新字
                charLoc = 	new CompoundPath();
                lastPara.chars.push(charLoc);
            }
            // 更新薪字
            charLoc.m = FMatrix.prototype.createFromFMatrix(lastCharLoc.m);// 复制最后一个字的matrix
            for(var k=0; k<charSrv.paths.length; k++){// 复制网络文字的轮廓
                var newPath = new PointPath();
                newPath.fromJson(charSrv.paths[k], define.VERSION_CURRENT);
                charLoc.paths.push(newPath);
            }
            charLoc.w = charSrv.w;
            charLoc.h = charSrv.h;
        }
    }
    
    // 将矩阵应用到文字点上
    this.multiplyMatrix();
}
